package abstractfactory

// AbstractFactory 抽象工厂的接口，声明创建抽象产品对象的操作
type AbstractFactory interface {
	// CreateProductA 示例方法，创建抽象产品A的对象
	// @return 抽象产品A的对象
	CreateProductA() AbstractProductA

	// CreateProductB 示例方法，创建抽象产品B的对象
	// @return 抽象产品B的对象
	CreateProductB() AbstractProductB
}

// AbstractProductA 抽象产品A的接口
type AbstractProductA interface {
	// 定义抽象产品A相关的操作
	testProductA() string
}

// AbstractProductB 抽象产品B的接口
type AbstractProductB interface {
	// 定义抽象产品B相关的操作
	testProductB() string
}

// ProductA1 产品A的具体实现
type ProductA1 struct {
}

// 实现产品A的接口中定义的操作
func (p *ProductA1) testProductA() string {
	return "ProductA1"
}

// ProductA2 产品A的具体实现
type ProductA2 struct {
}

// 实现产品A的接口中定义的操作
func (p *ProductA2) testProductA() string {
	return "ProductA2"
}

// ProductB1 产品B的具体实现
type ProductB1 struct {
}

// 实现产品B的接口中定义的操作
func (p *ProductB1) testProductB() string {
	return "ProductB1"
}

// ProductB2 产品B的具体实现
type ProductB2 struct {
}

// 实现产品B的接口中定义的操作
func (p *ProductB2) testProductB() string {
	return "ProductB2"
}

// ConcreteFactory1 具体的工厂实现对象，实现创建具体的产品对象的操作
type ConcreteFactory1 struct {
}

func (c *ConcreteFactory1) CreateProductA() AbstractProductA {
	return &ProductA1{}
}

func (c *ConcreteFactory1) CreateProductB() AbstractProductB {
	return &ProductB1{}
}

// ConcreteFactory2 具体的工厂实现对象，实现创建具体的产品对象的操作
type ConcreteFactory2 struct {
}

func (c *ConcreteFactory2) CreateProductA() AbstractProductA {
	return &ProductA2{}
}

func (c *ConcreteFactory2) CreateProductB() AbstractProductB {
	return &ProductB2{}
}
